//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS VoiceID service.
///
/// Amazon Connect Voice ID provides real-time caller authentication and fraud risk detection, which make voice interactions in contact centers more secure and efficient.
public struct VoiceID: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the VoiceID client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "VoiceID",
            serviceName: "VoiceID",
            serviceIdentifier: "voiceid",
            serviceProtocol: .json(version: "1.0"),
            apiVersion: "2021-09-27",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: VoiceIDErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "ca-central-1": "voiceid-fips.ca-central-1.amazonaws.com",
            "us-east-1": "voiceid-fips.us-east-1.amazonaws.com",
            "us-west-2": "voiceid-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Associates the fraudsters with the watchlist specified in the same domain.
    @Sendable
    @inlinable
    public func associateFraudster(_ input: AssociateFraudsterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateFraudsterResponse {
        try await self.client.execute(
            operation: "AssociateFraudster", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates the fraudsters with the watchlist specified in the same domain.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the fraudster.
    ///   - fraudsterId: The identifier of the fraudster to be associated with the watchlist.
    ///   - watchlistId: The identifier of the watchlist you want to associate with the fraudster.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateFraudster(
        domainId: String,
        fraudsterId: String,
        watchlistId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateFraudsterResponse {
        let input = AssociateFraudsterRequest(
            domainId: domainId, 
            fraudsterId: fraudsterId, 
            watchlistId: watchlistId
        )
        return try await self.associateFraudster(input, logger: logger)
    }

    /// Creates a domain that contains all Amazon Connect Voice ID data, such as speakers, fraudsters, customer audio, and voiceprints.  Every domain is created with a default watchlist that fraudsters can be a part of.
    @Sendable
    @inlinable
    public func createDomain(_ input: CreateDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDomainResponse {
        try await self.client.execute(
            operation: "CreateDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a domain that contains all Amazon Connect Voice ID data, such as speakers, fraudsters, customer audio, and voiceprints.  Every domain is created with a default watchlist that fraudsters can be a part of.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: A brief description of this domain.
    ///   - name: The name of the domain.
    ///   - serverSideEncryptionConfiguration: The configuration, containing the KMS key identifier, to be used by Voice ID for the server-side encryption of your data. Refer to  Amazon Connect Voice ID encryption at rest for more details on how the KMS key is used.
    ///   - tags: A list of tags you want added to the domain.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDomain(
        clientToken: String? = CreateDomainRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        serverSideEncryptionConfiguration: ServerSideEncryptionConfiguration,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDomainResponse {
        let input = CreateDomainRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            serverSideEncryptionConfiguration: serverSideEncryptionConfiguration, 
            tags: tags
        )
        return try await self.createDomain(input, logger: logger)
    }

    /// Creates a watchlist that fraudsters can be a part of.
    @Sendable
    @inlinable
    public func createWatchlist(_ input: CreateWatchlistRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWatchlistResponse {
        try await self.client.execute(
            operation: "CreateWatchlist", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a watchlist that fraudsters can be a part of.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: A brief description of this watchlist.
    ///   - domainId: The identifier of the domain that contains the watchlist.
    ///   - name: The name of the watchlist.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWatchlist(
        clientToken: String? = CreateWatchlistRequest.idempotencyToken(),
        description: String? = nil,
        domainId: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWatchlistResponse {
        let input = CreateWatchlistRequest(
            clientToken: clientToken, 
            description: description, 
            domainId: domainId, 
            name: name
        )
        return try await self.createWatchlist(input, logger: logger)
    }

    /// Deletes the specified domain from Voice ID.
    @Sendable
    @inlinable
    public func deleteDomain(_ input: DeleteDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified domain from Voice ID.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDomain(
        domainId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteDomainRequest(
            domainId: domainId
        )
        return try await self.deleteDomain(input, logger: logger)
    }

    /// Deletes the specified fraudster from Voice ID. This action disassociates the fraudster from any watchlists it is a part of.
    @Sendable
    @inlinable
    public func deleteFraudster(_ input: DeleteFraudsterRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteFraudster", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified fraudster from Voice ID. This action disassociates the fraudster from any watchlists it is a part of.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the fraudster.
    ///   - fraudsterId: The identifier of the fraudster you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFraudster(
        domainId: String,
        fraudsterId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteFraudsterRequest(
            domainId: domainId, 
            fraudsterId: fraudsterId
        )
        return try await self.deleteFraudster(input, logger: logger)
    }

    /// Deletes the specified speaker from Voice ID.
    @Sendable
    @inlinable
    public func deleteSpeaker(_ input: DeleteSpeakerRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteSpeaker", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified speaker from Voice ID.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the speaker.
    ///   - speakerId: The identifier of the speaker you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSpeaker(
        domainId: String,
        speakerId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteSpeakerRequest(
            domainId: domainId, 
            speakerId: speakerId
        )
        return try await self.deleteSpeaker(input, logger: logger)
    }

    /// Deletes the specified watchlist from Voice ID. This API throws an exception when there are fraudsters in the watchlist that you are trying to delete. You must delete the fraudsters, and then delete the watchlist. Every domain has a default watchlist which cannot be deleted.
    @Sendable
    @inlinable
    public func deleteWatchlist(_ input: DeleteWatchlistRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteWatchlist", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified watchlist from Voice ID. This API throws an exception when there are fraudsters in the watchlist that you are trying to delete. You must delete the fraudsters, and then delete the watchlist. Every domain has a default watchlist which cannot be deleted.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the watchlist.
    ///   - watchlistId: The identifier of the watchlist to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWatchlist(
        domainId: String,
        watchlistId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteWatchlistRequest(
            domainId: domainId, 
            watchlistId: watchlistId
        )
        return try await self.deleteWatchlist(input, logger: logger)
    }

    /// Describes the specified domain.
    @Sendable
    @inlinable
    public func describeDomain(_ input: DescribeDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeDomainResponse {
        try await self.client.execute(
            operation: "DescribeDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified domain.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that you are describing.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeDomain(
        domainId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeDomainResponse {
        let input = DescribeDomainRequest(
            domainId: domainId
        )
        return try await self.describeDomain(input, logger: logger)
    }

    /// Describes the specified fraudster.
    @Sendable
    @inlinable
    public func describeFraudster(_ input: DescribeFraudsterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFraudsterResponse {
        try await self.client.execute(
            operation: "DescribeFraudster", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified fraudster.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the fraudster.
    ///   - fraudsterId: The identifier of the fraudster you are describing.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFraudster(
        domainId: String,
        fraudsterId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFraudsterResponse {
        let input = DescribeFraudsterRequest(
            domainId: domainId, 
            fraudsterId: fraudsterId
        )
        return try await self.describeFraudster(input, logger: logger)
    }

    /// Describes the specified fraudster registration job.
    @Sendable
    @inlinable
    public func describeFraudsterRegistrationJob(_ input: DescribeFraudsterRegistrationJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFraudsterRegistrationJobResponse {
        try await self.client.execute(
            operation: "DescribeFraudsterRegistrationJob", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified fraudster registration job.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the fraudster registration job.
    ///   - jobId: The identifier of the fraudster registration job you are describing.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFraudsterRegistrationJob(
        domainId: String,
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFraudsterRegistrationJobResponse {
        let input = DescribeFraudsterRegistrationJobRequest(
            domainId: domainId, 
            jobId: jobId
        )
        return try await self.describeFraudsterRegistrationJob(input, logger: logger)
    }

    /// Describes the specified speaker.
    @Sendable
    @inlinable
    public func describeSpeaker(_ input: DescribeSpeakerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeSpeakerResponse {
        try await self.client.execute(
            operation: "DescribeSpeaker", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified speaker.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the speaker.
    ///   - speakerId: The identifier of the speaker you are describing.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeSpeaker(
        domainId: String,
        speakerId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeSpeakerResponse {
        let input = DescribeSpeakerRequest(
            domainId: domainId, 
            speakerId: speakerId
        )
        return try await self.describeSpeaker(input, logger: logger)
    }

    /// Describes the specified speaker enrollment job.
    @Sendable
    @inlinable
    public func describeSpeakerEnrollmentJob(_ input: DescribeSpeakerEnrollmentJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeSpeakerEnrollmentJobResponse {
        try await self.client.execute(
            operation: "DescribeSpeakerEnrollmentJob", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified speaker enrollment job.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the speaker enrollment job.
    ///   - jobId: The identifier of the speaker enrollment job you are describing.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeSpeakerEnrollmentJob(
        domainId: String,
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeSpeakerEnrollmentJobResponse {
        let input = DescribeSpeakerEnrollmentJobRequest(
            domainId: domainId, 
            jobId: jobId
        )
        return try await self.describeSpeakerEnrollmentJob(input, logger: logger)
    }

    /// Describes the specified watchlist.
    @Sendable
    @inlinable
    public func describeWatchlist(_ input: DescribeWatchlistRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeWatchlistResponse {
        try await self.client.execute(
            operation: "DescribeWatchlist", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified watchlist.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the watchlist.
    ///   - watchlistId: The identifier of the watchlist that you are describing.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeWatchlist(
        domainId: String,
        watchlistId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeWatchlistResponse {
        let input = DescribeWatchlistRequest(
            domainId: domainId, 
            watchlistId: watchlistId
        )
        return try await self.describeWatchlist(input, logger: logger)
    }

    /// Disassociates the fraudsters from the watchlist specified. Voice ID always expects a fraudster to be a part of at least one watchlist. If you try to disassociate a fraudster from its only watchlist, a ValidationException is thrown.
    @Sendable
    @inlinable
    public func disassociateFraudster(_ input: DisassociateFraudsterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateFraudsterResponse {
        try await self.client.execute(
            operation: "DisassociateFraudster", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates the fraudsters from the watchlist specified. Voice ID always expects a fraudster to be a part of at least one watchlist. If you try to disassociate a fraudster from its only watchlist, a ValidationException is thrown.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the fraudster.
    ///   - fraudsterId: The identifier of the fraudster to be disassociated from the watchlist.
    ///   - watchlistId: The identifier of the watchlist that you want to disassociate from the fraudster.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateFraudster(
        domainId: String,
        fraudsterId: String,
        watchlistId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateFraudsterResponse {
        let input = DisassociateFraudsterRequest(
            domainId: domainId, 
            fraudsterId: fraudsterId, 
            watchlistId: watchlistId
        )
        return try await self.disassociateFraudster(input, logger: logger)
    }

    /// Evaluates a specified session based on audio data accumulated during a streaming Amazon Connect Voice ID call.
    @Sendable
    @inlinable
    public func evaluateSession(_ input: EvaluateSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EvaluateSessionResponse {
        try await self.client.execute(
            operation: "EvaluateSession", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Evaluates a specified session based on audio data accumulated during a streaming Amazon Connect Voice ID call.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain where the session started.
    ///   - sessionNameOrId: The session identifier, or name of the session, that you want to evaluate. In Voice ID integration, this is the Contact-Id.
    ///   - logger: Logger use during operation
    @inlinable
    public func evaluateSession(
        domainId: String,
        sessionNameOrId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EvaluateSessionResponse {
        let input = EvaluateSessionRequest(
            domainId: domainId, 
            sessionNameOrId: sessionNameOrId
        )
        return try await self.evaluateSession(input, logger: logger)
    }

    /// Lists all the domains in the Amazon Web Services account.
    @Sendable
    @inlinable
    public func listDomains(_ input: ListDomainsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDomainsResponse {
        try await self.client.execute(
            operation: "ListDomains", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the domains in the Amazon Web Services account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - nextToken: If NextToken is returned, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDomains(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDomainsResponse {
        let input = ListDomainsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDomains(input, logger: logger)
    }

    /// Lists all the fraudster registration jobs in the domain with the given JobStatus. If JobStatus is not provided, this lists all fraudster registration jobs in the given domain.
    @Sendable
    @inlinable
    public func listFraudsterRegistrationJobs(_ input: ListFraudsterRegistrationJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFraudsterRegistrationJobsResponse {
        try await self.client.execute(
            operation: "ListFraudsterRegistrationJobs", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the fraudster registration jobs in the domain with the given JobStatus. If JobStatus is not provided, this lists all fraudster registration jobs in the given domain.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the fraudster registration Jobs.
    ///   - jobStatus: Provides the status of your fraudster registration job.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - nextToken: If NextToken is returned, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFraudsterRegistrationJobs(
        domainId: String,
        jobStatus: FraudsterRegistrationJobStatus? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFraudsterRegistrationJobsResponse {
        let input = ListFraudsterRegistrationJobsRequest(
            domainId: domainId, 
            jobStatus: jobStatus, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFraudsterRegistrationJobs(input, logger: logger)
    }

    /// Lists all fraudsters in a specified watchlist or domain.
    @Sendable
    @inlinable
    public func listFraudsters(_ input: ListFraudstersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFraudstersResponse {
        try await self.client.execute(
            operation: "ListFraudsters", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all fraudsters in a specified watchlist or domain.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - nextToken: If NextToken is returned, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours.
    ///   - watchlistId: The identifier of the watchlist. If provided, all fraudsters in the watchlist are listed. If not provided, all fraudsters in the domain are listed.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFraudsters(
        domainId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        watchlistId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFraudstersResponse {
        let input = ListFraudstersRequest(
            domainId: domainId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            watchlistId: watchlistId
        )
        return try await self.listFraudsters(input, logger: logger)
    }

    /// Lists all the speaker enrollment jobs in the domain with the specified JobStatus. If JobStatus is not provided, this lists all jobs with all possible speaker enrollment job statuses.
    @Sendable
    @inlinable
    public func listSpeakerEnrollmentJobs(_ input: ListSpeakerEnrollmentJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSpeakerEnrollmentJobsResponse {
        try await self.client.execute(
            operation: "ListSpeakerEnrollmentJobs", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the speaker enrollment jobs in the domain with the specified JobStatus. If JobStatus is not provided, this lists all jobs with all possible speaker enrollment job statuses.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the speaker enrollment jobs.
    ///   - jobStatus: Provides the status of your speaker enrollment Job.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - nextToken: If NextToken is returned, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSpeakerEnrollmentJobs(
        domainId: String,
        jobStatus: SpeakerEnrollmentJobStatus? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSpeakerEnrollmentJobsResponse {
        let input = ListSpeakerEnrollmentJobsRequest(
            domainId: domainId, 
            jobStatus: jobStatus, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSpeakerEnrollmentJobs(input, logger: logger)
    }

    /// Lists all speakers in a specified domain.
    @Sendable
    @inlinable
    public func listSpeakers(_ input: ListSpeakersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSpeakersResponse {
        try await self.client.execute(
            operation: "ListSpeakers", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all speakers in a specified domain.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - nextToken: If NextToken is returned, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSpeakers(
        domainId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSpeakersResponse {
        let input = ListSpeakersRequest(
            domainId: domainId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSpeakers(input, logger: logger)
    }

    /// Lists all tags associated with a specified Voice ID resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all tags associated with a specified Voice ID resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the Voice ID resource for which you want to list the tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Lists all watchlists in a specified domain.
    @Sendable
    @inlinable
    public func listWatchlists(_ input: ListWatchlistsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWatchlistsResponse {
        try await self.client.execute(
            operation: "ListWatchlists", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all watchlists in a specified domain.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - nextToken: If NextToken is returned, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWatchlists(
        domainId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWatchlistsResponse {
        let input = ListWatchlistsRequest(
            domainId: domainId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listWatchlists(input, logger: logger)
    }

    /// Opts out a speaker from Voice ID. A speaker can be opted out regardless of whether or not they already exist in Voice ID. If they don't yet exist, a new speaker is created in an opted out state. If they already exist, their existing status is overridden and they are opted out. Enrollment and evaluation authentication requests are rejected for opted out speakers, and opted out speakers have no voice embeddings stored in Voice ID.
    @Sendable
    @inlinable
    public func optOutSpeaker(_ input: OptOutSpeakerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> OptOutSpeakerResponse {
        try await self.client.execute(
            operation: "OptOutSpeaker", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Opts out a speaker from Voice ID. A speaker can be opted out regardless of whether or not they already exist in Voice ID. If they don't yet exist, a new speaker is created in an opted out state. If they already exist, their existing status is overridden and they are opted out. Enrollment and evaluation authentication requests are rejected for opted out speakers, and opted out speakers have no voice embeddings stored in Voice ID.
    ///
    /// Parameters:
    ///   - domainId: The identifier of the domain that contains the speaker.
    ///   - speakerId: The identifier of the speaker you want opted-out.
    ///   - logger: Logger use during operation
    @inlinable
    public func optOutSpeaker(
        domainId: String,
        speakerId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> OptOutSpeakerResponse {
        let input = OptOutSpeakerRequest(
            domainId: domainId, 
            speakerId: speakerId
        )
        return try await self.optOutSpeaker(input, logger: logger)
    }

    /// Starts a new batch fraudster registration job using provided details.
    @Sendable
    @inlinable
    public func startFraudsterRegistrationJob(_ input: StartFraudsterRegistrationJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartFraudsterRegistrationJobResponse {
        try await self.client.execute(
            operation: "StartFraudsterRegistrationJob", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a new batch fraudster registration job using provided details.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - dataAccessRoleArn: The IAM role Amazon Resource Name (ARN) that grants Voice ID permissions to access customer's buckets to read the input manifest file and write the Job output file. Refer to the Create and edit a fraudster watchlist documentation for the permissions needed in this role.
    ///   - domainId: The identifier of the domain that contains the fraudster registration job and in which the fraudsters are registered.
    ///   - inputDataConfig: The input data config containing an S3 URI for the input manifest file that contains the list of fraudster registration requests.
    ///   - jobName: The name of the new fraudster registration job.
    ///   - outputDataConfig: The output data config containing the S3 location where Voice ID writes the job output file; you must also include a KMS key ID to encrypt the file.
    ///   - registrationConfig: The registration config containing details such as the action to take when a duplicate fraudster is detected, and the similarity threshold to use for detecting a duplicate fraudster.
    ///   - logger: Logger use during operation
    @inlinable
    public func startFraudsterRegistrationJob(
        clientToken: String? = StartFraudsterRegistrationJobRequest.idempotencyToken(),
        dataAccessRoleArn: String,
        domainId: String,
        inputDataConfig: InputDataConfig,
        jobName: String? = nil,
        outputDataConfig: OutputDataConfig,
        registrationConfig: RegistrationConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartFraudsterRegistrationJobResponse {
        let input = StartFraudsterRegistrationJobRequest(
            clientToken: clientToken, 
            dataAccessRoleArn: dataAccessRoleArn, 
            domainId: domainId, 
            inputDataConfig: inputDataConfig, 
            jobName: jobName, 
            outputDataConfig: outputDataConfig, 
            registrationConfig: registrationConfig
        )
        return try await self.startFraudsterRegistrationJob(input, logger: logger)
    }

    /// Starts a new batch speaker enrollment job using specified details.
    @Sendable
    @inlinable
    public func startSpeakerEnrollmentJob(_ input: StartSpeakerEnrollmentJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartSpeakerEnrollmentJobResponse {
        try await self.client.execute(
            operation: "StartSpeakerEnrollmentJob", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a new batch speaker enrollment job using specified details.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - dataAccessRoleArn: The IAM role Amazon Resource Name (ARN) that grants Voice ID permissions to access customer's buckets to read the input manifest file and write the job output file. Refer to Batch enrollment using audio data from prior calls for the permissions needed in this role.
    ///   - domainId: The identifier of the domain that contains the speaker enrollment job and in which the speakers are enrolled.
    ///   - enrollmentConfig: The enrollment config that contains details such as the action to take when a speaker is already enrolled in Voice ID or when a speaker is identified as a fraudster.
    ///   - inputDataConfig: The input data config containing the S3 location for the input manifest file that contains the list of speaker enrollment requests.
    ///   - jobName: A name for your speaker enrollment job.
    ///   - outputDataConfig: The output data config containing the S3 location where Voice ID writes the job output file; you must also include a KMS key ID to encrypt the file.
    ///   - logger: Logger use during operation
    @inlinable
    public func startSpeakerEnrollmentJob(
        clientToken: String? = StartSpeakerEnrollmentJobRequest.idempotencyToken(),
        dataAccessRoleArn: String,
        domainId: String,
        enrollmentConfig: EnrollmentConfig? = nil,
        inputDataConfig: InputDataConfig,
        jobName: String? = nil,
        outputDataConfig: OutputDataConfig,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartSpeakerEnrollmentJobResponse {
        let input = StartSpeakerEnrollmentJobRequest(
            clientToken: clientToken, 
            dataAccessRoleArn: dataAccessRoleArn, 
            domainId: domainId, 
            enrollmentConfig: enrollmentConfig, 
            inputDataConfig: inputDataConfig, 
            jobName: jobName, 
            outputDataConfig: outputDataConfig
        )
        return try await self.startSpeakerEnrollmentJob(input, logger: logger)
    }

    /// Tags a Voice ID resource with the provided list of tags.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Tags a Voice ID resource with the provided list of tags.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the Voice ID resource you want to tag.
    ///   - tags: The list of tags to assign to the specified resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes specified tags from a specified Amazon Connect Voice ID resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes specified tags from a specified Amazon Connect Voice ID resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the Voice ID resource you want to remove tags from.
    ///   - tagKeys: The list of tag keys you want to remove from the specified resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the specified domain. This API has clobber behavior, and clears and replaces all attributes. If an optional field, such as 'Description' is not provided, it is removed from the domain.
    @Sendable
    @inlinable
    public func updateDomain(_ input: UpdateDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDomainResponse {
        try await self.client.execute(
            operation: "UpdateDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified domain. This API has clobber behavior, and clears and replaces all attributes. If an optional field, such as 'Description' is not provided, it is removed from the domain.
    ///
    /// Parameters:
    ///   - description: A brief description about this domain.
    ///   - domainId: The identifier of the domain to be updated.
    ///   - name: The name of the domain.
    ///   - serverSideEncryptionConfiguration: The configuration, containing the KMS key identifier, to be used by Voice ID for the server-side encryption of your data. Changing the domain's associated KMS key immediately triggers an asynchronous process to remove dependency on the old KMS key, such that the domain's data can only be accessed using the new KMS key. The domain's ServerSideEncryptionUpdateDetails contains the details for this process.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDomain(
        description: String? = nil,
        domainId: String,
        name: String,
        serverSideEncryptionConfiguration: ServerSideEncryptionConfiguration,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDomainResponse {
        let input = UpdateDomainRequest(
            description: description, 
            domainId: domainId, 
            name: name, 
            serverSideEncryptionConfiguration: serverSideEncryptionConfiguration
        )
        return try await self.updateDomain(input, logger: logger)
    }

    /// Updates the specified watchlist. Every domain has a default watchlist which cannot be updated.
    @Sendable
    @inlinable
    public func updateWatchlist(_ input: UpdateWatchlistRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateWatchlistResponse {
        try await self.client.execute(
            operation: "UpdateWatchlist", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified watchlist. Every domain has a default watchlist which cannot be updated.
    ///
    /// Parameters:
    ///   - description: A brief description about this watchlist.
    ///   - domainId: The identifier of the domain that contains the watchlist.
    ///   - name: The name of the watchlist.
    ///   - watchlistId: The identifier of the watchlist to be updated.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWatchlist(
        description: String? = nil,
        domainId: String,
        name: String? = nil,
        watchlistId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateWatchlistResponse {
        let input = UpdateWatchlistRequest(
            description: description, 
            domainId: domainId, 
            name: name, 
            watchlistId: watchlistId
        )
        return try await self.updateWatchlist(input, logger: logger)
    }
}

extension VoiceID {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: VoiceID, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension VoiceID {
    /// Return PaginatorSequence for operation ``listDomains(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDomainsPaginator(
        _ input: ListDomainsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDomainsRequest, ListDomainsResponse> {
        return .init(
            input: input,
            command: self.listDomains,
            inputKey: \ListDomainsRequest.nextToken,
            outputKey: \ListDomainsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDomains(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDomainsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDomainsRequest, ListDomainsResponse> {
        let input = ListDomainsRequest(
            maxResults: maxResults
        )
        return self.listDomainsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFraudsterRegistrationJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFraudsterRegistrationJobsPaginator(
        _ input: ListFraudsterRegistrationJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFraudsterRegistrationJobsRequest, ListFraudsterRegistrationJobsResponse> {
        return .init(
            input: input,
            command: self.listFraudsterRegistrationJobs,
            inputKey: \ListFraudsterRegistrationJobsRequest.nextToken,
            outputKey: \ListFraudsterRegistrationJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFraudsterRegistrationJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainId: The identifier of the domain that contains the fraudster registration Jobs.
    ///   - jobStatus: Provides the status of your fraudster registration job.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFraudsterRegistrationJobsPaginator(
        domainId: String,
        jobStatus: FraudsterRegistrationJobStatus? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFraudsterRegistrationJobsRequest, ListFraudsterRegistrationJobsResponse> {
        let input = ListFraudsterRegistrationJobsRequest(
            domainId: domainId, 
            jobStatus: jobStatus, 
            maxResults: maxResults
        )
        return self.listFraudsterRegistrationJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFraudsters(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFraudstersPaginator(
        _ input: ListFraudstersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFraudstersRequest, ListFraudstersResponse> {
        return .init(
            input: input,
            command: self.listFraudsters,
            inputKey: \ListFraudstersRequest.nextToken,
            outputKey: \ListFraudstersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFraudsters(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainId: The identifier of the domain.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - watchlistId: The identifier of the watchlist. If provided, all fraudsters in the watchlist are listed. If not provided, all fraudsters in the domain are listed.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFraudstersPaginator(
        domainId: String,
        maxResults: Int? = nil,
        watchlistId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFraudstersRequest, ListFraudstersResponse> {
        let input = ListFraudstersRequest(
            domainId: domainId, 
            maxResults: maxResults, 
            watchlistId: watchlistId
        )
        return self.listFraudstersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSpeakerEnrollmentJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSpeakerEnrollmentJobsPaginator(
        _ input: ListSpeakerEnrollmentJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSpeakerEnrollmentJobsRequest, ListSpeakerEnrollmentJobsResponse> {
        return .init(
            input: input,
            command: self.listSpeakerEnrollmentJobs,
            inputKey: \ListSpeakerEnrollmentJobsRequest.nextToken,
            outputKey: \ListSpeakerEnrollmentJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSpeakerEnrollmentJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainId: The identifier of the domain that contains the speaker enrollment jobs.
    ///   - jobStatus: Provides the status of your speaker enrollment Job.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSpeakerEnrollmentJobsPaginator(
        domainId: String,
        jobStatus: SpeakerEnrollmentJobStatus? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSpeakerEnrollmentJobsRequest, ListSpeakerEnrollmentJobsResponse> {
        let input = ListSpeakerEnrollmentJobsRequest(
            domainId: domainId, 
            jobStatus: jobStatus, 
            maxResults: maxResults
        )
        return self.listSpeakerEnrollmentJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSpeakers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSpeakersPaginator(
        _ input: ListSpeakersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSpeakersRequest, ListSpeakersResponse> {
        return .init(
            input: input,
            command: self.listSpeakers,
            inputKey: \ListSpeakersRequest.nextToken,
            outputKey: \ListSpeakersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSpeakers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainId: The identifier of the domain.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSpeakersPaginator(
        domainId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSpeakersRequest, ListSpeakersResponse> {
        let input = ListSpeakersRequest(
            domainId: domainId, 
            maxResults: maxResults
        )
        return self.listSpeakersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWatchlists(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWatchlistsPaginator(
        _ input: ListWatchlistsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWatchlistsRequest, ListWatchlistsResponse> {
        return .init(
            input: input,
            command: self.listWatchlists,
            inputKey: \ListWatchlistsRequest.nextToken,
            outputKey: \ListWatchlistsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWatchlists(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainId: The identifier of the domain.
    ///   - maxResults: The maximum number of results that are returned per call. You can use NextToken to obtain more pages of results. The default is 100; the maximum allowed page size is also 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWatchlistsPaginator(
        domainId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWatchlistsRequest, ListWatchlistsResponse> {
        let input = ListWatchlistsRequest(
            domainId: domainId, 
            maxResults: maxResults
        )
        return self.listWatchlistsPaginator(input, logger: logger)
    }
}

extension VoiceID.ListDomainsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VoiceID.ListDomainsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension VoiceID.ListFraudsterRegistrationJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VoiceID.ListFraudsterRegistrationJobsRequest {
        return .init(
            domainId: self.domainId,
            jobStatus: self.jobStatus,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension VoiceID.ListFraudstersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VoiceID.ListFraudstersRequest {
        return .init(
            domainId: self.domainId,
            maxResults: self.maxResults,
            nextToken: token,
            watchlistId: self.watchlistId
        )
    }
}

extension VoiceID.ListSpeakerEnrollmentJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VoiceID.ListSpeakerEnrollmentJobsRequest {
        return .init(
            domainId: self.domainId,
            jobStatus: self.jobStatus,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension VoiceID.ListSpeakersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VoiceID.ListSpeakersRequest {
        return .init(
            domainId: self.domainId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension VoiceID.ListWatchlistsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VoiceID.ListWatchlistsRequest {
        return .init(
            domainId: self.domainId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
